ஜாஸ்கிரிப்ட் மேம்பாட்டு சூழல் மேம்பாடு: கொள்கலன் செயல்திறன் சரிசெய்தல்

கொள்கலன்கள் மென்பொருள் மேம்பாட்டில் புரட்சியை ஏற்படுத்தியுள்ளன, உருவாக்குதல், சோதனை செய்தல் மற்றும் பயன்பாடுகளை செயல்படுத்துவதற்கு ஒரு நிலையான மற்றும் தனிமைப்படுத்தப்பட்ட சூழலை வழங்குகின்றன. ஜாவாஸ்கிரிப்ட் மேம்பாட்டிற்கு இது மிகவும் உண்மை, அங்கு சார்புநிலை மேலாண்மை மற்றும் சூழல் முரண்பாடுகள் ஒரு குறிப்பிடத்தக்க சவாலாக இருக்கலாம். இருப்பினும், கொள்கலனுக்குள் உங்கள் ஜாவாஸ்கிரிப்ட் மேம்பாட்டு சூழலை இயக்குவது எப்போதும் பெட்டிக்கு வெளியே செயல்திறன் வெற்றியாக இருக்காது. சரியான சரிசெய்தல் இல்லாமல், கொள்கலன்கள் சில நேரங்களில் மேலதிக செலவை அறிமுகப்படுத்தி, உங்கள் பணிப்பாய்வை மெதுவாக்கும். இந்தக் கட்டுரை, உச்ச செயல்திறன் மற்றும் செயல்திறனை அடைய கொள்கலன்களுக்குள் உங்கள் ஜாவாஸ்கிரிப்ட் மேம்பாட்டு சூழலை மேம்படுத்துவதற்கான வழிகாட்டும்.

உங்கள் ஜாவாஸ்கிரிப்ட் மேம்பாட்டு சூழலை ஏன் கொள்கலன மயமாக்க வேண்டும்?

மேம்பாட்டில் இறங்குவதற்கு முன், ஜாவாஸ்கிரிப்ட் மேம்பாட்டிற்காக கொள்கலன்களைப் பயன்படுத்துவதன் முக்கிய நன்மைகளை மீண்டும் நினைவுபடுத்திப் பார்ப்போம்:

• நிலையான தன்மை: குழுவில் உள்ள அனைவரும் ஒரே சூழலைப் பயன்படுத்துவதை உறுதி செய்கிறது, "இது எனது இயந்திரத்தில் வேலை செய்கிறது" சிக்கல்களை நீக்குகிறது. இதில் Node.js பதிப்புகள், npm/yarn பதிப்புகள், இயக்க முறைமை சார்புகள் மற்றும் பல அடங்கும்.
• தனிமைப்படுத்தல்: வெவ்வேறு திட்டங்களுக்கும் அவற்றின் சார்புகளுக்கும் இடையே ஏற்படும் மோதல்களைத் தடுக்கிறது. நீங்கள் வெவ்வேறு Node.js பதிப்புகளைக் கொண்ட பல திட்டங்களை ஒரே நேரத்தில் தலையீடு இல்லாமல் இயக்கலாம்.
• மீளுருவாக்கம்: எந்த இயந்திரத்திலும் மேம்பாட்டுச் சூழலை மீண்டும் உருவாக்க எளிதாக்குகிறது, இது ஆன் போர்டிங் மற்றும் சிக்கல் தீர்த்தலை எளிதாக்குகிறது.
• போர்ட்டபிலிட்டி: உள்ளூர் இயந்திரங்கள், கிளவுட் சேவையகங்கள் மற்றும் CI/CD குழாய்கள் உட்பட பல்வேறு தளங்களில் உங்கள் மேம்பாட்டுச் சூழலை தடையின்றி நகர்த்த உங்களை அனுமதிக்கிறது.
• அளவிடுதல்: Kubernetes போன்ற கொள்கலன் ஒருங்கிணைப்பு தளங்களுடன் ஒருங்கிணைக்கிறது, தேவைக்கேற்ப உங்கள் மேம்பாட்டுச் சூழலை அளவிட உதவுகிறது.

கொள்கலன் செய்யப்பட்ட ஜாவாஸ்கிரிப்ட் மேம்பாட்டில் பொதுவான செயல்திறன் இடையூறுகள்

நன்மைகள் இருந்தபோதிலும், கொள்கலன் செய்யப்பட்ட ஜாவாஸ்கிரிப்ட் மேம்பாட்டுச் சூழல்களில் செயல்திறன் இடையூறுகளுக்கு வழிவகுக்கும் பல காரணிகள் உள்ளன:

• வளக் கட்டுப்பாடுகள்: கொள்கலன்கள் ஹோஸ்ட் இயந்திரத்தின் வளங்களைப் பகிர்ந்து கொள்கின்றன (CPU, நினைவகம், வட்டு I/O). சரியாக கட்டமைக்கப்படாவிட்டால், ஒரு கொள்கலன் அதன் வள ஒதுக்கீட்டில் குறைவாக இருக்கலாம், இதன் விளைவாக மெதுவாக்கம் ஏற்படும்.
• கோப்பு முறைமை செயல்திறன்: கொள்கலனுள் கோப்புகளைப் படித்தல் மற்றும் எழுதுதல் ஹோஸ்ட் இயந்திரத்தை விட மெதுவாக இருக்கலாம், குறிப்பாக ஏற்றப்பட்ட தொகுதிகளைப் பயன்படுத்தும் போது.
• நெட்வொர்க் ஓவர்ஹெட்: கொள்கலனுக்கும் ஹோஸ்ட் இயந்திரத்திற்கும் அல்லது பிற கொள்கலன்களுக்கும் இடையிலான நெட்வொர்க் தொடர்பு தாமதத்தை ஏற்படுத்தக்கூடும்.
• திறமையற்ற பட அடுக்குகள்: மோசமாக கட்டமைக்கப்பட்ட டாकर படங்கள் பெரிய பட அளவுகளிலும், மெதுவான கட்டும் நேரங்களிலும் ஏற்படலாம்.
• CPU தீவிரமான பணிகள்: பேபலுடன் டிரான்ஸ்பைலேஷன், சிறியதாக்குதல் மற்றும் சிக்கலான பில்ட் செயல்முறைகள் CPU தீவிரமானதாக இருக்கலாம் மற்றும் முழு கொள்கலன் செயல்முறையையும் மெதுவாக்கும்.

ஜாவாஸ்கிரிப்ட் மேம்பாட்டு கொள்கலன்களுக்கான மேம்பாட்டு நுட்பங்கள்

1. வள ஒதுக்கீடு மற்றும் வரம்புகள்

உங்கள் கொள்கலனுக்கு வளங்களை சரியாக ஒதுக்குவது செயல்திறனுக்கு முக்கியமானது. டாकर கம்போஸ் அல்லது `டாकर ரன்` கட்டளையைப் பயன்படுத்தி வள ஒதுக்கீட்டைக் கட்டுப்படுத்தலாம். இந்தக் காரணிகளைக் கவனியுங்கள்:

• CPU வரம்புகள்: `--cpus` கொடி அல்லது டாकर கம்போஸில் உள்ள `cpus` விருப்பத்தைப் பயன்படுத்தி கொள்கலனுக்குக் கிடைக்கும் CPU கோர்களின் எண்ணிக்கையை வரம்பிடவும். CPU வளங்களை மிக அதிகமாக ஒதுக்கீடு செய்வதைத் தவிர்க்கவும், ஏனெனில் இது ஹோஸ்ட் இயந்திரத்தில் மற்ற செயல்முறைகளுடன் போட்டியிடுவதற்கு வழிவகுக்கும். உங்கள் பணிச்சுமைக்கு சரியான சமநிலையைக் கண்டறிய பரிசோதனை செய்யுங்கள். உதாரணம்: `--cpus="2"` அல்லது `cpus: 2`
• நினைவக வரம்புகள்: `--memory` அல்லது `-m` கொடியைப் பயன்படுத்தி நினைவக வரம்புகளை அமைக்கவும் (எ.கா., `--memory="2g"`) அல்லது டாकर கம்போஸில் உள்ள `mem_limit` விருப்பம் (எ.கா., `mem_limit: 2g`). கொள்கலனில் போதுமான நினைவகம் இருப்பதை உறுதிசெய்து, அது ஸ்வாப் செய்வதைத் தவிர்க்கவும், இது செயல்திறனை கணிசமாகக் குறைக்கும். உங்கள் பயன்பாடு பொதுவாகப் பயன்படுத்துவதை விட சற்று அதிகமான நினைவகத்தை ஒதுக்குவது ஒரு நல்ல ஆரம்ப புள்ளியாகும்.
• CPU இணைப்பு: `--cpuset-cpus` கொடியைப் பயன்படுத்தி கொள்கலனை குறிப்பிட்ட CPU கோர்களுக்கு பின் செய்யவும். இது சூழல் மாறலைக் குறைப்பதன் மூலமும், கேச் லோகாலிடியை மேம்படுத்துவதன் மூலமும் செயல்திறனை மேம்படுத்தலாம். இந்த விருப்பத்தைப் பயன்படுத்தும் போது கவனமாக இருங்கள், ஏனெனில் இது கிடைக்கக்கூடிய வளங்களைப் பயன்படுத்த கொள்கலனின் திறனைக் கட்டுப்படுத்தலாம். உதாரணம்: `--cpuset-cpus="0,1"`.

உதாரணம் (டாकर கம்போஸ்):

version: "3.8"
services:
 web:
 image: node:16
 ports:
 - "3000:3000"
 volumes:
 - .:/app
 working_dir: /app
 command: npm start
 deploy:
 resources:
 limits:
 cpus: '2'
 memory: 2g

2. கோப்பு முறைமை செயல்திறனை மேம்படுத்துதல்

கோப்பு முறைமை செயல்திறன் பெரும்பாலும் கொள்கலன் செய்யப்பட்ட மேம்பாட்டுச் சூழல்களில் ஒரு பெரிய இடையூறாக உள்ளது. அதை மேம்படுத்த சில நுட்பங்கள் இங்கே:

• பெயரிடப்பட்ட தொகுதிகளைப் பயன்படுத்துதல்: பைண்ட் மவுண்ட்களுக்குப் பதிலாக (ஹோஸ்ட்டிலிருந்து நேரடியாக கோப்பகங்களை ஏற்றுதல்), பெயரிடப்பட்ட தொகுதிகளைப் பயன்படுத்தவும். டாकर மூலம் பெயரிடப்பட்ட தொகுதிகள் நிர்வகிக்கப்படுகின்றன மற்றும் சிறந்த செயல்திறனை வழங்க முடியும். பைண்ட் மவுண்டுகள் பெரும்பாலும் ஹோஸ்ட் மற்றும் கொள்கலனுக்கு இடையே கோப்பு முறைமை மொழிபெயர்ப்பு காரணமாக செயல்திறன் மேலதிக செலவுடன் வருகின்றன.
• டாकर டெஸ்க்டாப் செயல்திறன் அமைப்புகள்: நீங்கள் டாकर டெஸ்க்டாப்பை (macOS அல்லது Windows இல்) பயன்படுத்தினால், கோப்பு பகிர்வு அமைப்புகளை சரிசெய்யவும். டாकर டெஸ்க்டாப் கொள்கலன்களை இயக்க ஒரு மெய்நிகர் இயந்திரத்தைப் பயன்படுத்துகிறது, மேலும் ஹோஸ்ட் மற்றும் VM இடையே கோப்பு பகிர்வு மெதுவாக இருக்கலாம். வெவ்வேறு கோப்பு பகிர்வு நெறிமுறைகளுடன் பரிசோதனை செய்யுங்கள் (எ.கா., gRPC FUSE, VirtioFS) மற்றும் VMக்கு ஒதுக்கப்பட்ட வளங்களை அதிகரிக்கவும்.
• மியூட்டஜென் (macOS/Windows): macOS மற்றும் Windows இல் ஹோஸ்ட் மற்றும் டாकर கொள்கலன்களுக்கு இடையே கோப்பு முறைமை செயல்திறனை மேம்படுத்த வடிவமைக்கப்பட்ட ஒரு கோப்பு ஒத்திசைவு கருவியான மியூட்டஜென் பயன்படுத்துவதைக் கவனியுங்கள். இது பின்னணியில் கோப்புகளை ஒத்திசைக்கிறது, கிட்டத்தட்ட சொந்த செயல்திறனை வழங்குகிறது.
• tmpfs ஏற்றங்கள்: நிரந்தரமாக வைக்க வேண்டிய அவசியமில்லாத தற்காலிக கோப்புகள் அல்லது கோப்பகங்களுக்கு, `tmpfs` ஏற்றத்தைப் பயன்படுத்தவும். `tmpfs` ஏற்றங்கள் நினைவகத்தில் கோப்புகளை சேமிக்கின்றன, மிக வேகமாக அணுகலை வழங்குகின்றன. இது `node_modules` அல்லது உருவாக்க கலைப்பொருட்களுக்கு குறிப்பாகப் பயனுள்ளதாக இருக்கும். உதாரணம்: `volumes: - myvolume:/path/in/container:tmpfs`.
• அதிகப்படியான கோப்பு I/O ஐத் தவிர்க்கவும்: கொள்கலனுள் செய்யப்படும் கோப்பு I/O இன் அளவைக் குறைக்கவும். இதில் வட்டில் எழுதப்பட்ட கோப்புகளின் எண்ணிக்கையைக் குறைத்தல், கோப்பு அளவுகளை மேம்படுத்துதல் மற்றும் கேச்சிங்கைப் பயன்படுத்துதல் ஆகியவை அடங்கும்.

உதாரணம் (பெயரிடப்பட்ட தொகுதியுடன் டாकर கம்போஸ்):

version: "3.8"
services:
 web:
 image: node:16
 ports:
 - "3000:3000"
 volumes:
 - app_data:/app
 working_dir: /app
 command: npm start
volumes:
 app_data:

உதாரணம் (மியூட்டஜெனுடன் டாकर கம்போஸ் - மியூட்டஜென் நிறுவப்பட்டு கட்டமைக்கப்பட வேண்டும்):

version: "3.8"
services:
 web:
 image: node:16
 ports:
 - "3000:3000"
 volumes:
 - mutagen:/app
 working_dir: /app
 command: npm start
volumes:
 mutagen:
 driver: mutagen

3. டாकर பட அளவு மற்றும் கட்டும் நேரங்களை மேம்படுத்துதல்

ஒரு பெரிய டாकर படம் மெதுவான கட்டும் நேரங்கள், அதிகரித்த சேமிப்பு செலவுகள் மற்றும் மெதுவான செயல்படுத்துதல் நேரங்களுக்கு வழிவகுக்கும். பட அளவை குறைக்க மற்றும் கட்டும் நேரங்களை மேம்படுத்த சில நுட்பங்கள் இங்கே:

• மல்டி-ஸ்டேஜ் உருவாக்குகிறது: உருவாக்க சூழலை ரன்டைம் சூழலில் இருந்து பிரிக்க மல்டி-ஸ்டேஜ் உருவாக்குகிறது. இது இறுதி படத்தில் சேர்க்காமல் பில்ட் கருவிகள் மற்றும் சார்புகளை உருவாக்க உங்களை அனுமதிக்கிறது. இது இறுதி படத்தின் அளவை கணிசமாகக் குறைக்கிறது.
• குறைந்தபட்ச அடிப்படைப் படத்தைப் பயன்படுத்தவும்: உங்கள் கொள்கலனுக்கான குறைந்தபட்ச அடிப்படைப் படத்தைத் தேர்வு செய்யவும். Node.js பயன்பாடுகளுக்கு, நிலையான `node` படத்தை விட கணிசமாக சிறியதான `node:alpine` படத்தைப் பயன்படுத்துவதைக் கவனியுங்கள். Alpine Linux என்பது சிறிய அடிச்சுவடு கொண்ட ஒரு இலகுரக விநியோகமாகும்.
• அடுக்கு வரிசையை மேம்படுத்துதல்: டாकर இன் லேயர் கேச்சிங்கின் பலனைப் பெற உங்கள் டாकरஃபைல் வழிமுறைகளை வரிசைப்படுத்துங்கள். அடிக்கடி மாறும் வழிமுறைகளை (எ.கா., பயன்பாட்டு குறியீட்டை நகலெடுப்பது) டாकरஃபைலின் முடிவிலும், குறைவாக மாறும் வழிமுறைகளை (எ.கா., கணினி சார்புகளை நிறுவுதல்) ஆரம்பத்திலும் வைக்கவும். இது டாकर மீண்டும் கேச் செய்யப்பட்ட அடுக்குகளைப் பயன்படுத்த அனுமதிக்கிறது, அடுத்தடுத்த உருவாக்கங்களை கணிசமாக துரிதப்படுத்துகிறது.
• தேவையற்ற கோப்புகளை சுத்தம் செய்யுங்கள்: இனி தேவையில்லாத படத்திலிருந்து தேவையற்ற கோப்புகளை அகற்றவும். இதில் தற்காலிக கோப்புகள், பில்ட் கலைப்பொருட்கள் மற்றும் ஆவணங்கள் ஆகியவை அடங்கும். இந்த கோப்புகளை அகற்ற `rm` கட்டளை அல்லது மல்டி-ஸ்டேஜ் பில்ட்களைப் பயன்படுத்தவும்.
• `.dockerignore` ஐப் பயன்படுத்தவும்: படத்திற்கு நகலெடுப்பதிலிருந்து தேவையற்ற கோப்புகள் மற்றும் கோப்பகங்களை விலக்க `.dockerignore` கோப்பை உருவாக்கவும். இது படத்தின் அளவு மற்றும் கட்டும் நேரத்தை கணிசமாகக் குறைக்கும். `node_modules`, `.git` மற்றும் வேறு ஏதேனும் பெரிய அல்லது பொருத்தமற்ற கோப்புகளை விலக்கவும்.

உதாரணம் (மல்டி-ஸ்டேஜ் பில்டுடன் டாकरஃபைல்):

# நிலை 1: பயன்பாட்டை உருவாக்குதல்
FROM node:16 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# நிலை 2: ரன்டைம் படத்தை உருவாக்குதல்
FROM node:16-alpine
WORKDIR /app
COPY --from=builder /app/dist .  # உருவாக்க கலைப்பொருட்களை மட்டும் நகலெடுக்கவும்
COPY package*.json ./
RUN npm install --production  # உற்பத்தி சார்புகளை மட்டும் நிறுவவும்
CMD ["npm", "start"]

4. Node.js குறிப்பிட்ட மேம்பாடுகள்

உங்கள் Node.js பயன்பாட்டை மேம்படுத்துவதும் கொள்கலனுக்குள் செயல்திறனை மேம்படுத்தும்:

• உற்பத்தி பயன்முறையைப் பயன்படுத்துக: `NODE_ENV` சூழல் மாறியை `production` என அமைப்பதன் மூலம் உங்கள் Node.js பயன்பாட்டை உற்பத்தி பயன்முறையில் இயக்கவும். இது பிழைத்திருத்தம் மற்றும் ஹாட் ரீலோடிங் போன்ற மேம்பாட்டு நேர அம்சங்களை முடக்குகிறது, இது செயல்திறனை மேம்படுத்தும்.
• சார்புகளை மேம்படுத்துதல்: உற்பத்திக்குத் தேவையான சார்புகளை மட்டும் நிறுவ `npm prune --production` அல்லது `yarn install --production` பயன்படுத்தவும். மேம்பாட்டுச் சார்புகள் உங்கள் `node_modules` கோப்பகத்தின் அளவை கணிசமாக அதிகரிக்கக்கூடும்.
• கோட் ஸ்ப்ளிட்டிங்: உங்கள் பயன்பாட்டின் ஆரம்ப ஏற்றுதல் நேரத்தைக் குறைக்க கோட் ஸ்ப்ளிட்டிங்கைச் செயல்படுத்தவும். Webpack மற்றும் Parcel போன்ற கருவிகள் உங்கள் குறியீட்டை சிறிய பகுதிகளாகப் பிரித்து தேவைக்கேற்ப ஏற்றும்.
• கேச்சிங்: உங்கள் சேவையகத்திற்கான கோரிக்கைகளின் எண்ணிக்கையைக் குறைக்க கேச்சிங் வழிமுறைகளைச் செயல்படுத்தவும். இதை உள் நினைவக கேச், ரெடிஸ் அல்லது மெம்கேஷ்ட் போன்ற வெளிப்புற கேச் அல்லது உலாவி கேச்சிங் மூலம் செய்யலாம்.
• புரொபைலிங்: உங்கள் குறியீட்டில் உள்ள செயல்திறன் இடையூறுகளை அடையாளம் காண புரொபைலிங் கருவிகளைப் பயன்படுத்தவும். Node.js ஆனது மெதுவாக இயங்கும் செயல்பாடுகளைக் கண்டறிந்து உங்கள் குறியீட்டை மேம்படுத்த உதவும் உள்ளமைக்கப்பட்ட புரொபைலிங் கருவிகளை வழங்குகிறது.
• சரியான Node.js பதிப்பைத் தேர்வு செய்யவும்: Node.js இன் புதிய பதிப்புகளில் பெரும்பாலும் செயல்திறன் மேம்பாடுகள் மற்றும் மேம்படுத்தல்கள் அடங்கும். சமீபத்திய நிலையான பதிப்பிற்கு தொடர்ந்து புதுப்பிக்கவும்.

உதாரணம் (டாकर கம்போஸில் NODE_ENV அமைத்தல்):

version: "3.8"
services:
 web:
 image: node:16
 ports:
 - "3000:3000"
 volumes:
 - .:/app
 working_dir: /app
 command: npm start
environment:
 NODE_ENV: production

5. நெட்வொர்க் மேம்பாடு

கொள்கலன்களுக்கும் ஹோஸ்ட் இயந்திரத்திற்கும் இடையிலான நெட்வொர்க் தொடர்பும் செயல்திறனை பாதிக்கலாம். சில மேம்படுத்தல் நுட்பங்கள் இங்கே:

• ஹோஸ்ட் நெட்வொர்க்கைப் பயன்படுத்துதல் (கவனமாக): சில சந்தர்ப்பங்களில், `--network="host"` விருப்பத்தைப் பயன்படுத்துவது நெட்வொர்க் மெய்நிகராக்க மேலதிக செலவை நீக்குவதன் மூலம் செயல்திறனை மேம்படுத்தலாம். இருப்பினும், இது கொள்கலனின் போர்ட்களை நேரடியாக ஹோஸ்ட் இயந்திரத்திற்கு வெளிப்படுத்துகிறது, இது பாதுகாப்பு அபாயங்கள் மற்றும் போர்ட் மோதல்களை உருவாக்கலாம். இந்த விருப்பத்தை எச்சரிக்கையுடன் பயன்படுத்தவும், தேவைப்பட்டால் மட்டுமே பயன்படுத்தவும்.
• உள் DNS: வெளிப்புற DNS சேவையகங்களைச் சார்ந்திருப்பதற்குப் பதிலாக கொள்கலன் பெயர்களைத் தீர்க்க டாकर இன் உள் DNS ஐப் பயன்படுத்தவும். இது தாமதத்தைக் குறைத்து நெட்வொர்க் தீர்மான வேகத்தை மேம்படுத்தும்.
• நெட்வொர்க் கோரிக்கைகளை குறைக்கவும்: உங்கள் பயன்பாட்டினால் செய்யப்படும் நெட்வொர்க் கோரிக்கைகளின் எண்ணிக்கையைக் குறைக்கவும். பல கோரிக்கைகளை ஒரே கோரிக்கையாக இணைப்பதன் மூலமும், தரவை கேச்சிங் செய்வதன் மூலமும், திறமையான தரவு வடிவங்களைப் பயன்படுத்துவதன் மூலமும் இதைச் செய்யலாம்.

6. கண்காணிப்பு மற்றும் புரொபைலிங்

செயல்திறன் இடையூறுகளை அடையாளம் காணவும், உங்கள் மேம்பாடுகள் பயனுள்ளதாக இருப்பதை உறுதி செய்யவும், உங்கள் கொள்கலன் செய்யப்பட்ட ஜாவாஸ்கிரிப்ட் மேம்பாட்டுச் சூழலை தொடர்ந்து கண்காணிக்கவும் மற்றும் சுயவிவரப்படுத்தவும்.

• டாकर புள்ளிவிவரங்கள்: CPU, நினைவகம் மற்றும் நெட்வொர்க் I/O உட்பட உங்கள் கொள்கலன்களின் வள பயன்பாட்டை கண்காணிக்க `டாकर புள்ளிவிவரங்கள்` கட்டளையைப் பயன்படுத்தவும்.
• புரொபைலிங் கருவிகள்: உங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டை சுயவிவரப்படுத்தவும் மற்றும் செயல்திறன் இடையூறுகளை அடையாளம் காணவும் Node.js இன்ஸ்பெக்டர் அல்லது Chrome DevTools போன்ற புரொபைலிங் கருவிகளைப் பயன்படுத்தவும்.
• லாக்ஜிங்: பயன்பாட்டு நடத்தையை கண்காணிக்கவும் மற்றும் சாத்தியமான சிக்கல்களை அடையாளம் காணவும் விரிவான லாக்ஜிங்கை செயல்படுத்தவும். அனைத்து கொள்கலன்களிலிருந்தும் லாக்களை சேகரிக்கவும் மற்றும் பகுப்பாய்வு செய்யவும் ஒரு மையப்படுத்தப்பட்ட லாக்கிங் அமைப்பைப் பயன்படுத்தவும்.
• உண்மையான பயனர் கண்காணிப்பு (RUM): உண்மையான பயனர்களின் கண்ணோட்டத்தில் உங்கள் பயன்பாட்டின் செயல்திறனைக் கண்காணிக்க RUM ஐ செயல்படுத்தவும். இது மேம்பாட்டுச் சூழலில் காணப்படாத செயல்திறன் சிக்கல்களை அடையாளம் காண உதவும்.

உதாரணம்: டாकर மூலம் ஒரு ரியாக்ட் மேம்பாட்டுச் சூழலை மேம்படுத்துதல்

டாकर ஐப் பயன்படுத்தி ஒரு ரியாக்ட் மேம்பாட்டுச் சூழலை மேம்படுத்துவதன் நடைமுறை உதாரணத்துடன் இந்த நுட்பங்களை விளக்குவோம்.

1. ஆரம்ப அமைவு (மெதுவான செயல்திறன்): அனைத்து திட்டக் கோப்புகளையும் நகலெடுக்கும், சார்புகளை நிறுவும் மற்றும் மேம்பாட்டு சேவையகத்தைத் தொடங்கும் ஒரு அடிப்படை டாकरஃபைல். இது பைண்ட் மவுண்ட்கள் காரணமாக மெதுவான கட்டும் நேரங்கள் மற்றும் கோப்பு முறைமை செயல்திறன் சிக்கல்களால் பாதிக்கப்படுகிறது.
2. மேம்படுத்தப்பட்ட டாकरஃபைல் (வேகமான உருவாக்கங்கள், சிறிய படம்): பில்ட் மற்றும் ரன்டைம் சூழல்களைப் பிரிக்க மல்டி-ஸ்டேஜ் பில்ட்களை செயல்படுத்துதல். `node:alpine` ஐ அடிப்படை படமாகப் பயன்படுத்துதல். உகந்த கேச்சிங்கிற்காக டாकरஃபைல் வழிமுறைகளை வரிசைப்படுத்துதல். தேவையற்ற கோப்புகளை விலக்க `.dockerignore` ஐப் பயன்படுத்துதல்.
3. டாकर கம்போஸ் கட்டமைப்பு (வள ஒதுக்கீடு, பெயரிடப்பட்ட தொகுதிகள்): CPU மற்றும் நினைவகத்திற்கான வள வரம்புகளை வரையறுத்தல். பைண்ட் மவுண்ட்களில் இருந்து பெயரிடப்பட்ட தொகுதிகளுக்கு மாறுதல், மேம்படுத்தப்பட்ட கோப்பு முறைமை செயல்திறனுக்காக. டாकर டெஸ்க்டாப்பைப் பயன்படுத்தினால், மியூட்டஜெனை ஒருங்கிணைத்தல்.
4. Node.js மேம்பாடுகள் (வேகமான மேம்பாட்டு சேவையகம்): `NODE_ENV=development` அமைத்தல். API இறுதிப் புள்ளிகள் மற்றும் பிற உள்ளமைவு அளவுருக்களுக்கு சூழல் மாறிகளைப் பயன்படுத்துதல். சேவையக சுமையைக் குறைக்க கேச்சிங் உத்திகளை செயல்படுத்துதல்.

முடிவுரை

கொள்கலன்களுக்குள் உங்கள் ஜாவாஸ்கிரிப்ட் மேம்பாட்டுச் சூழலை மேம்படுத்துவதற்கு ஒரு பலதரப்பட்ட அணுகுமுறை தேவைப்படுகிறது. வள ஒதுக்கீடு, கோப்பு முறைமை செயல்திறன், பட அளவு, Node.js-குறிப்பிட்ட மேம்பாடுகள் மற்றும் நெட்வொர்க் உள்ளமைவைக் கருத்தில் கொள்வதன் மூலம், செயல்திறன் மற்றும் திறனை நீங்கள் கணிசமாக மேம்படுத்தலாம். ஏதேனும் புதிய இடையூறுகளை அடையாளம் கண்டு தீர்க்க, உங்கள் சூழலை தொடர்ந்து கண்காணிக்கவும் மற்றும் சுயவிவரப்படுத்தவும் நினைவில் கொள்ளுங்கள். இந்த நுட்பங்களை செயல்படுத்துவதன் மூலம், உங்கள் குழுவினருக்கு வேகமான, மிகவும் நம்பகமான மற்றும் மிகவும் நிலையான மேம்பாட்டு அனுபவத்தை உருவாக்க முடியும், இறுதியில் அதிக உற்பத்தித்திறன் மற்றும் சிறந்த மென்பொருள் தரத்திற்கு வழிவகுக்கும். கொள்கலன்மயமாக்கல், சரியாகச் செய்தால், ஜே.எஸ். டெவலப்மென்ட்டிற்கு ஒரு பெரிய வெற்றியாகும்.

மேலும், இணையான உருவாக்குதலுக்காக BuildKit ஐப் பயன்படுத்துதல் மற்றும் கூடுதல் செயல்திறன் ஆதாயங்களுக்காக மாற்று கொள்கலன் ரன்டைம்களை ஆராய்தல் போன்ற மேம்பட்ட நுட்பங்களை ஆராய்வதைக் கவனியுங்கள்.